#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;

//
//int main() {
//    string str;
//    cin >> str;
//    reverse(str.begin(), str.end());
//    int n = str.size();
//    string ret;
//    for (int i = 0; i < n; i++)
//    {
//        ret += str[i];
//        if (((i + 1) % 3 == 0) && (i != n - 1))
//        {
//            ret += ',';
//        }
//    }
//    reverse(ret.begin(), ret.end());
//    cout << ret << endl;
//    return 0;
//}
//
//int main() {
//    int n;
//    cin >> n;
//    if (n <= 2)
//    {
//        cout << n << endl;
//    }
//    else
//    {
//        int prev = 1;
//        int cur = 2;
//        for (int i = 3; i <= n; i++)
//        {
//            int sum = prev + cur;
//            prev = cur;
//            cur = sum;
//        }
//        cout << cur << endl;
//    }
//    return 0;
//}
//
//class Solution {
//public:
//    bool IsContinuous(vector<int>& numbers) {
//        // write code here
//        int n = numbers.size();
//        sort(numbers.begin(), numbers.end());
//        int arr[14] = { 0 };
//        for (auto s : numbers)
//        {
//            arr[s]++;
//        }
//        int left = 1;
//        int right = 1;
//        int length = 0;
//        int k = arr[0];
//        while (right < 14)
//        {
//            if (arr[right] == 0 && k > 0)
//            {
//                k--;
//            }
//            else if (arr[right] == 0 && k == 0)
//            {
//                while (left < right && k == 0)
//                {
//                    if (arr[left] == 0)
//                    {
//                        left++;
//                        break;
//                    }
//                    left++;
//                }
//            }
//            length = max(length, right - left + 1);
//            right++;
//        }
//        if (length == n)
//        {
//            return true;
//        }
//        return false;
//    }
//};

class Solution {
public:
    int longestPalindrome(string s) {
        vector<int> arr(255);
        for (auto str : s)
        {
            arr[str]++;
        }
        int sum = 0;
        int prev = 0;
        for (int i = 0; i < 255; i++)
        {
            if (arr[i] % 2 == 0)
            {
                sum += arr[i];
            }
            else
            {
                prev = 1;
                sum += max(0, arr[i] - 1);
            }
        }
        if (prev == 1)
        {
            sum += 1;
        }
        return sum;
    }
};

int main() {
    int n;
    cin >> n;
    int arr[n];
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    int prev = arr[0];
    int my_max = 0;
    for (int i = 0; i < n; i++)
    {
        if (arr[i] > prev)
        {
            my_max = max(my_max, arr[i] - prev);
        }
        else
        {
            prev = arr[i];
        }
    }
    cout << my_max << endl;
    return 0;
}

#include <iostream>
using namespace std;

int n, m, x, y;
long long board[22][22] = { 0 };

int dx[8] = { -2,-2,-1,-1,1,1,2,2 };
int dy[8] = { -1,1,-2,2,-2,2,-1,1 };

int main() {
    cin >> n >> m >> x >> y;
    n += 1;
    m += 1;
    x += 1;
    y += 1;
    board[x][y] = -1;
    for (int i = 0; i < 8; i++)
    {
        int x1 = dx[i] + x;
        int y1 = dy[i] + y;
        if (x1 > 0 && x1 <= n && y1 > 0 && y1 <= m)
        {
            board[x1][y1] = -1;
        }
    }
    board[0][1] = 1;
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            if (board[i][j] != -1)
            {
                board[i][j] = (board[i - 1][j] > 0 ? board[i - 1][j] : 0) + (board[i][j - 1] > 0 ? board[i][j - 1] : 0);
            }
        }
    }
    cout << board[n][m] << endl;
    return 0;
}

class Solution {
public:
    int my_reverse(string& s, int left, int right)
    {
        int ret = 0;
        while (left >= 0 && right < s.size())
        {
            if (s[left] != s[right])
            {
                break;
            }
            ret = max(ret, right - left + 1);
            left--;
            right++;
        }
        return ret;
    }

    int getLongestPalindrome(string A) {
        // write code here
        int my_max = 1;
        int n = A.size();
        for (int i = 0; i < n; i++)
        {
            my_max = max(my_max, max(my_reverse(A, i - 1, i), my_reverse(A, i - 1, i + 1)));
        }
        return my_max;
    }
};

int main() {
    int n;
    cin >> n;
    int arr[n];
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    int prev = arr[0];
    int sum = 0;
    for (int i = 0; i < n; i++)
    {
        if (arr[i] > prev)
        {
            sum += (arr[i] - prev);
            prev = arr[i];
        }
        else
        {
            prev = arr[i];
        }
    }
    cout << sum << endl;
    return 0;
}